package top.minuy.structure.linear.linked;
/**
 * @author Minuy
 * @time 08:01
 * @date 2021/8/25
 */
public class RecursiveLinkedList<E> {
    // 头节点
    Node<E> head;
    // 链表大小
    int size;

    public RecursiveLinkedList() {
        head = null;
        size = 0;
    }

    /**
     * 插入一个元素
     * @param index 元素插入位置
     * @param e 插入的元素
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Index is illegal.");
        }

        this.head = add(this.head, index, e);

        size++;
    }

    /**
     * 插入递归函数
     * @param miniHead 处理的新链表
     * @param index 要在新链表中插入的位置
     * @param e 要插入的元素
     * @return 新的链表
     */
    private Node<E> add(Node<E> miniHead, int index, E e) {
        if (index == 0 || index == size) {
            // System.out.println("添加节点");
            // 添加到miniHead的前面
            miniHead = new Node<E>(e, miniHead);
        } else {
            if(miniHead == null){
                return null;
            }
            // System.out.println("head 不为空，添加一个节点");
            miniHead.next = add(miniHead.next, index - 1, e);
        }
        return miniHead;
    }

    /**
     * 从链表中删除一个元素
     * @param index 要删除元素的索引
     */
    public void remove(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }
        head = remove(head,index);
        size--;
    }

    /**
     * 删除一个元素递归函数
     * @param miniHead 新的链表头
     * @param index 要删除的元素在新链表中的索引
     * @return 一个处理好的新链表
     */
    private Node<E> remove(Node<E> miniHead,int index){
        if(index == 0){
            return miniHead.next;
        }
        miniHead.next = remove(miniHead.next,index-1);
        return miniHead;
    }


    /**
     * 获取一个元素
     * @param index 元素索引
     */
    public E get(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        return get(head,index).e;
    }

    /**
     * 获取一个元素递归函数
     * @param miniHead 新链表头
     * @param index 要获取元素的索引
     * @return 要获取的元素
     */
    private Node<E> get(Node<E> miniHead,int index){
        if(index == 0){
            return miniHead;
        }
        return get(miniHead.next, index-1);
    }

    /**
     * 设置元素的值
     * @param index 元素所在位置
     * @param e 新的元素值
     */
    public void set(int index,E e){
        if(index<0||index>=size){
            throw new IllegalArgumentException("Set failed. Index is illegal.");
        }

        set(head,index,e);
    }

    /**
     * 设置元素的值
     * @param miniHead 新链表
     * @param index 要修改的元素索引
     * @param e 新元素的值
     */
    private void set(Node<E> miniHead,int index,E e){
        if(index == 0){
            miniHead.e = e;
        }else {
            set(miniHead.next, index - 1, e);
        }
    }

    @Override
    public String toString() {
        return String.format("LinkedList : size=%d\n%s", this.size, builderString(head));
    }

    private String builderString(Node<E> head) {
        if (head == null) {
            return " -> null";
        } else {
            return " -> " + head.e.toString() + builderString(head.next);
        }
    }
}
